home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / Font.C < prev    next >
C/C++ Source or Header  |  1990-12-06  |  10KB  |  484 lines
  1. #include <stdio.h>
  2.  
  3. #include "Font.h"
  4. #include "Error.h"
  5. #include "String.h"
  6. #include "WindowSystem.h"
  7.  
  8. #define FACES       5    /* Bold, Italic, Underline, Outline, Shadow */
  9. #define MAXFACES    32   /* 2**FACES */
  10. #define MAXFAMILIES 30
  11. #define FONTTABLE  "FontTab"
  12. #define FontNameTemplate "%s%02d%s"
  13.  
  14. Font *gSysFont,
  15.      *gApplFont,
  16.      *gFixedFont;
  17.        
  18. class FontManager *gFontManager;
  19. char *FontLib;
  20.  
  21. SimpleMetaImpl(Font)
  22. {
  23.     sprintf(buf, "%s", ((Font*) addr)->AsString());
  24. }
  25.  
  26. //---- Font --------------------------------------------------------------
  27.  
  28. Font *new_Font(GrFont font, int size, GrFace face)
  29. { 
  30.     return gFontManager->MapFont(font, size, face);
  31. }
  32.  
  33. Font *Font::WithFace(GrFace fc)
  34. {
  35.     return new_Font(family, size, fc);
  36. }
  37.  
  38. Font *Font::WithSize(int sz)
  39. {
  40.     return new_Font(family, sz, face);
  41. }
  42.  
  43. bool Font::Loaded()
  44. {
  45.     return TRUE;
  46. }
  47.  
  48. Font *Font::Load()
  49. {
  50.     if (! Loaded() && LoadFont())
  51.     return 0;
  52.     return this;
  53. }
  54.     
  55. char *Font::AsString()
  56. {
  57.     return form("%s.%d.%s", gFontManager->IdToName(Fid()), Size(),
  58.                         gFontManager->StyleString(Face()));
  59. }
  60.  
  61. int Font::Width(register byte *s, register int l)
  62. {
  63.     register int w= 0;
  64.     
  65.     if (s) {
  66.     if (l < 0) {
  67.         while(*s)
  68.         w+= cw[*s++];
  69.     } else {
  70.         while(--l >= 0)
  71.         w+= cw[*s++];
  72.     }
  73.     }
  74.     return w;
  75. }
  76.  
  77. int Font::MaxWidth(int l)
  78. {
  79.     if (width < 0) {
  80.     register int i;
  81.     
  82.     width= 0;
  83.     for (i= 0; i< 255; i++)
  84.         width= max(width, cw[i]);
  85.     }
  86.     return l*width;
  87. }
  88.  
  89. Rectangle Font::BBox(register byte *s, register int l)
  90. {
  91.     register int w= 0;
  92.     
  93.     if (s == 0)
  94.     return gRect0;
  95.     if (l < 0) {
  96.     while(*s)
  97.         w+= cw[*s++];
  98.     } else {
  99.     while(--l >= 0)
  100.         w+= cw[*s++];
  101.     }
  102.     return Rectangle(0, ht, w, ht+bs);
  103. }
  104.  
  105. Metric Font::GetMetric(register byte *s, register int l)
  106. {
  107.     register int w= 0;
  108.     
  109.     if (s == 0)
  110.     return Metric(0);
  111.     if (l < 0) {
  112.     while(*s)
  113.         w+= cw[*s++];
  114.     } else {
  115.     while(--l >= 0)
  116.         w+= cw[*s++];
  117.     }
  118.     return Metric(w, Ascender()+Descender(), Ascender());
  119. }
  120.  
  121. Metric Font::GetMetric(byte c)
  122. {
  123.     return Metric(Width(c), Ascender()+Descender(), Ascender());
  124. }
  125.  
  126. Rectangle Font::BBox(register byte c, Point pos)
  127. {
  128.     return Rectangle(pos.x, pos.y-Ascender(), Width(c), Spacing());
  129. }
  130.  
  131. bool Font::LoadFont()
  132. {
  133.     return FALSE;
  134. }
  135.  
  136. Font *Font::MakeFont(Font**, GrFace)
  137. {
  138.     return this;
  139. }
  140.  
  141. Point Font::AdjustString(register byte *s, Point p, GrVAdjust va, GrHAdjust ha)
  142. {
  143.     register int w= 0;
  144.     
  145.     if (s)
  146.     while(*s)
  147.        w+= cw[*s++];
  148.     
  149.     switch (ha) {
  150.     case eAdjHRight:
  151.     p.x-= w;
  152.     break;
  153.     case eAdjHCenter:
  154.     p.x-= w/2;
  155.     break;
  156.     default:
  157.     break;
  158.     }
  159.     switch (va) {
  160.     case eAdjVBottom:
  161.     p.y-= bs;
  162.     break;
  163.     case eAdjVCenter:
  164.     p.y+= (ht-bs)/2;
  165.     break;
  166.     case eAdjVTop:
  167.     p.y+= ht;
  168.     break;
  169.     case eAdjVBase:
  170.     break;
  171.     }
  172.     return p;
  173. }
  174.  
  175. DevBitmap *Font::CharAsBitmap(byte, Point*)
  176. {
  177.     return 0;
  178. }
  179.  
  180. void Font::CheckChar(byte c)
  181. {
  182.     register FontPtr *fdptr;
  183.     int facebit, ff;
  184.     
  185.     fdptr= gFontManager->MapFamilySize((GrFont)family, size);
  186.     ff= eFacePlain;
  187.     facebit= eFaceBold;
  188.     while (face != ff) {
  189.     if (face & facebit) {
  190.         fdptr[ff|facebit]->MakeChar(fdptr[ff], (GrFace)facebit, c, fdptr[ff & 7]);
  191.         ff|= facebit;
  192.     }
  193.     facebit<<= 1;
  194.     }
  195. }
  196.  
  197. void Font::MakeChar(Font*, GrFace, byte, Font*)
  198. {
  199. }
  200.  
  201. ostream& Font::StoreOn(ostream &s)
  202. {
  203.     return s << (int)family SP << (int)size SP << (int)face SP;
  204. }
  205.  
  206. ostream& operator<< (ostream &s, FontPtr &fp)
  207. {
  208.     return fp->StoreOn(s);
  209. }
  210.  
  211. istream& operator>> (istream &s, FontPtr &fp)
  212. {
  213.     GrFont fid;
  214.     GrFace fc;
  215.     int ps;
  216.     
  217.     s >> Enum(fid) >> ps >> Enum(fc);
  218.     fp= gFontManager->MapFont(fid, ps, fc);
  219.     return s;
  220. }
  221.  
  222. //---- misc ---------------------------------------------------------------------
  223.  
  224. char *FontManager::StyleString(GrFace face)
  225. {
  226.     static char buf[20];
  227.     char *cp= buf;
  228.     if (face == eFacePlain)
  229.     *cp++= 'r';
  230.     else {
  231.     if (face & eFaceBold)
  232.         *cp++= 'b';
  233.     if (face & eFaceItalic)
  234.         *cp++= 'i';
  235.     if (face & eFaceUnderline)
  236.         *cp++= 'u';
  237.     if (face & eFaceOutline)
  238.         *cp++= 'o';
  239.     if (face & eFaceShadow)
  240.         *cp++= 's';
  241.     }
  242.     *cp= '\0';
  243.     return buf;
  244. }
  245.  
  246. //---- FontManager -------------------------------------------------------------
  247.  
  248. FontManager::FontManager(char *etdir)
  249. {
  250.     FontLib= fontDir= etdir;
  251.     fmap= new FontFamilyPtr[MAXFAMILIES];
  252. }
  253.  
  254. FontManager::~FontManager()
  255. {
  256.     for (int f= 0; f < MAXFAMILIES; f++)
  257.     SafeDelete(fmap[f]);
  258.     SafeDelete(fmap);
  259. }
  260.  
  261. bool FontManager::Init()
  262. {
  263.     char *psname, family[40], fontname[80], name[40], buf[80];
  264.     FILE *fonts;
  265.     int fid, psfont, c, size;
  266.     bool firstchar;
  267.     GrFace style;
  268.     
  269.     if ((fonts= fopen(form("./%s", FONTTABLE), "r")) == 0)
  270.     if ((fonts= fopen(form("%s/%s", fontDir, FONTTABLE), "r")) == 0)
  271.         Fatal("FontManager::FontManager", "can't locate %s", FONTTABLE);
  272.        
  273.     // read available fonts
  274.     while (fscanf(fonts, "%d %s %s %d", &fid, name, family, &psfont) == 4) {
  275.     if (fid < 0 || fid >= MAXFAMILIES) {
  276.         Error("FontManager::FontManager", "fid out of range", FALSE);
  277.         continue;
  278.     }
  279.     fmap[fid]= new FontFamily((GrFont)fid, name, family, psfont);
  280.     firstchar= TRUE;
  281.     style= eFacePlain;
  282.     
  283.     while (c= fgetc(fonts)) {
  284.         switch (c) {
  285.         case EOF:
  286.         break;
  287.         case 'r':
  288.         if (firstchar)
  289.             firstchar= FALSE;
  290.         style= eFacePlain;
  291.         break;
  292.         case 'b':
  293.         if (firstchar) {
  294.             style= eFacePlain;
  295.             firstchar= FALSE;
  296.         }
  297.         style= (GrFace)(style|eFaceBold);
  298.         break;
  299.         case 'i':
  300.         if (firstchar) {
  301.             style= eFacePlain;
  302.             firstchar= FALSE;
  303.         }
  304.         style= (GrFace)(style|eFaceItalic);
  305.         break;
  306.         case '\n':
  307.         goto out;
  308.         default:
  309.         if (Isdigit(c)) {
  310.             size= 0;
  311.             while (Isdigit(c)) {
  312.             size= size * 10 + (c-'0');
  313.             c= fgetc(fonts);
  314.             }
  315.             ungetc(c, fonts);
  316.             sprintf(fontname, FontNameTemplate, family, size,
  317.                     gFontManager->StyleString(style));
  318.             fmap[fid]->AddFont(fontname, style, size);
  319.             firstchar= TRUE;
  320.         }
  321.         break;
  322.         }
  323.     }
  324. out:    ;
  325.     }
  326.  
  327.     fclose(fonts);
  328.     
  329.     if ((psname= gSystem->getenv("ET_FONT_SIZE")) == 0)
  330.     psname= "12";
  331.     size= atoi(psname);
  332.     
  333.     gSysFont= new_Font(eFontChicago, size);
  334.     gApplFont= new_Font(eFontMonaco, size);
  335.     gFixedFont= new_Font(eFontCourier, size);
  336.  
  337.     return FALSE;
  338. }
  339.  
  340. Font *FontManager::MakeFont(char*, GrFont, int, GrFace)
  341. {
  342.     return 0;
  343. }
  344.     
  345. Font *FontManager::MapFont(GrFont font, int size, GrFace face)
  346. {
  347.     if (font < 0 || font >= MAXFAMILIES || fmap[font] == 0)
  348.     return gSysFont;
  349.     return MapFamily(font)->MapSizeFace(size, face);
  350. }
  351.  
  352. int FontManager::NameToId(char *fontname)
  353. {
  354.     for (int i= 0; i < MAXFAMILIES; i++)
  355.     if (fmap[i] && fmap[i]->Name() && strcmp(fmap[i]->Name(), fontname) == 0)
  356.         return i;
  357.     return -1;
  358. }
  359.  
  360. char *FontManager::IdToName(GrFont fid)
  361. {
  362.     if (fid >= 0 && fid < MAXFAMILIES && fmap[fid])
  363.     return fmap[fid]->Name();
  364.     return 0;
  365. }
  366.  
  367. Font *FontManager::ScaleFont(Font*, GrFont, int, GrFace)
  368. {
  369.     return 0;
  370. }
  371.  
  372. //---- FontFamily --------------------------------------------------------------
  373.  
  374. FontFamily::FontFamily(GrFont fid, char *nm, char *family, bool psfont)
  375. {
  376.     familyid= fid;
  377.     name1= strsave(family);
  378.     name= strsave(nm);
  379.     ispsfont= psfont;
  380. }
  381.  
  382. FontFamily::~FontFamily()
  383. {
  384.     int s, ss, fc;
  385.     
  386.     for (s= 0; s < SIZES; s++) {
  387.     if (smap[s]) {
  388.         for (ss= s+1; ss < SIZES; ss++)
  389.         if (smap[s] == smap[ss])
  390.             smap[ss]= 0;    // don't delete smap twice
  391.         for (fc= 0; fc < MAXFACES; fc++)
  392.         if (smap[s][fc] && smap[s][fc]->Size())
  393.             SafeDelete(smap[s][fc]);
  394.         SafeDelete(smap[s]);
  395.     }
  396.     }
  397.     SafeDelete(name1);
  398.     SafeDelete(name);
  399. }
  400.  
  401. void FontFamily::AddFont(char *fontname, GrFace fc, int ps)
  402. {
  403.     int internalsize;
  404.     FontPtr *fdptr;
  405.     
  406.     if (ps < MINSIZE || ps > MAXSIZE)
  407.     Error("FontFamily::AddFont:", "size out of range", FALSE);
  408.     if (fc < 0 || fc >= MAXFACES)
  409.     Error("FontFamily::AddFont:", "face out of range", FALSE);
  410.     
  411.     internalsize= ps-MINSIZE;
  412.     if (smap[internalsize] == 0)
  413.     smap[internalsize]= new FontPtr[MAXFACES];
  414.     fdptr= smap[internalsize];
  415.     
  416.     fdptr[fc]= gFontManager->MakeFont(fontname, familyid, ps, fc);
  417. }
  418.  
  419. Font **FontFamily::MapSize(int size)
  420. {
  421.     Font *fp= 0, **ffp= 0;
  422.     register int s, try, i;
  423.     
  424.     size= range(MINSIZE, MAXSIZE, size);
  425.     s= size-MINSIZE;
  426.     
  427.     if (smap[s])
  428.     return smap[s];
  429.     
  430.     // try twice a bigger font
  431.     try= size * 2;
  432.     if (try <= MAXSIZE && smap[try-MINSIZE]
  433.                     && (fp= smap[try-MINSIZE][eFacePlain]))
  434.     fp= gFontManager->ScaleFont(fp->Load(), familyid, size, eFacePlain);
  435.     
  436.     if (fp == 0) {  // try twice a smaller font
  437.     try= size / 2;
  438.     if (try >= MINSIZE && smap[try-MINSIZE]
  439.                     && (fp= smap[try-MINSIZE][eFacePlain]))
  440.         fp= gFontManager->ScaleFont(fp->Load(), familyid, size, eFacePlain);
  441.     }
  442.     
  443.     if (fp == 0) {  // try nearest font
  444.     for (i= 1; i < MAXSIZE-MINSIZE; i++) {
  445.         if (s-i >= 0 && (smap[s]= smap[s-i]))
  446.         break;
  447.         if (s+i <= MAXSIZE-MINSIZE && (smap[s]= smap[s+i]))
  448.         break;
  449.     }
  450.     }
  451.     
  452.     if (fp) {
  453.     if (smap[s] == 0)
  454.         smap[s]= new FontPtr[MAXFACES];
  455.     smap[s][eFacePlain]= fp;
  456.     }
  457.     
  458.     return smap[s];
  459. }
  460.  
  461. Font *FontFamily::MapSizeFace(int size, GrFace face)
  462. {
  463.     int ff, facebit;
  464.     Font **fdptr= MapSize(size);
  465.     
  466.     if (face < 0 || face >= MAXFACES)
  467.     face= eFacePlain;
  468.     
  469.     if (fdptr[face])
  470.     return fdptr[face]->Load();
  471.     
  472.     ff= eFacePlain;
  473.     facebit= eFaceBold;
  474.     while (face != ff) {
  475.     if (face & facebit) {
  476.         if (fdptr[ff | facebit] == 0)
  477.         fdptr[ff | facebit]= fdptr[ff]->Load()->MakeFont(fdptr, (GrFace)facebit);
  478.         ff|= facebit;
  479.     }
  480.     facebit<<= 1;
  481.     }
  482.     return fdptr[face];
  483. }
  484.